SIMILAR TO previously passed the pattern straight to Arrow's regex engine, so SQL wildcards were never translated and matches were unanchored:

SELECT 'abc' SIMILAR TO 'a%';  -- returned false
SELECT 'x'   SIMILAR TO '_';   -- returned false

Translate % to (?s:.*) and _ to (?s:.) (dot-all so they match newlines), then wrap the pattern in ^(?:...)$ so the regex matches the entire string. ., ^, $, and \ are escaped as SQL literals. The POSIX metacharacters that SIMILAR TO defines (| * + ? ( ) { } [ ]) pass through to the regex unchanged.

Which issue does this PR close?

• Closes PostgreSQL compatibility: SIMILAR TO should treat % as a wildcard #22263.

Rationale for this change

SIMILAR TO is a SQL standard operator with well-defined wildcard semantics (% = any sequence, _ = single character, full-string match). DataFusion's previous behavior silently produced wrong results for the most basic patterns, which is a correctness bug for anyone porting queries from Postgres or other SQL engines.

Supporting non-literal patterns requires a new physical expression, so that expression also needs protobuf support — otherwise serialized physical plans containing a dynamic SIMILAR TO would regress for distributed engines built on datafusion-proto.

Accepting LargeUtf8 and Utf8View patterns in turn requires type coercion. Expr::SimilarTo was previously in the analyzer's no-op list, so nothing reconciled the value type with the pattern type. Since the regex kernel dispatches on the left-hand type and then downcasts the pattern to that same array type, any mismatch aborted the query with a failed to downcast array panic.

What changes are included in this PR?

Pattern translation

• Added a sql_similar_to_regex helper that translates %/_ and anchors the pattern with ^(?:...)$. It tracks bracket state so ^ inside [...] is treated as bracket negation, not as a literal, and so SQL wildcards lose their special meaning inside a bracket expression.
• Added a new SqlSimilarToPattern physical expression in datafusion/physical-expr/src/expressions/similar_to_pattern.rs that applies the translation at runtime for non-literal patterns.
• similar_to() now translates literal Utf8 / LargeUtf8 / Utf8View patterns at planning time and wraps non-literal patterns in SqlSimilarToPattern for runtime translation.
• NULL patterns pass through and return NULL instead of crashing with an internal error. The translation preserves the pattern's string variant, including for NULL, so the pattern type always matches the value type.
• Restored a plan-time type check in datafusion/sql/src/expr/mod.rs that rejects non-string patterns with a clean plan_err!.
• Runtime type errors in SqlSimilarToPattern are reported as exec_err! rather than internal_err!.

Type coercion

• Added an Expr::SimilarTo arm to datafusion/optimizer/src/analyzer/type_coercion.rs and removed Expr::SimilarTo from the no-op list. It uses regex_coercion, the same coercion Operator::RegexMatch already uses, since that is what SIMILAR TO lowers to. Mismatched string types are now cast to a common type instead of reaching the kernel and panicking.

Protobuf support

• Added a PhysicalSqlSimilarToPatternNode message and wired it into PhysicalExprNode.expr_type as field 24.
• Implemented try_to_proto / try_from_proto for SqlSimilarToPattern and added the decode arm in datafusion/proto/src/physical_plan/from_proto.rs.
• Regenerated prost.rs / pbjson.rs via datafusion/proto-models/regen.sh.

Are these changes tested?

Yes.

Pattern semantics (datafusion/physical-expr/src/expressions/binary.rs):

• test_similar_to_sql_literal_metachars confirms that ., ^, $, and \ are treated as SQL literals, not as regex operators.
• test_similar_to_posix_metachars confirms that |, *, +, ?, (, ), {, }, [, ], [^...], and [a-z] behave as SIMILAR TO metacharacters.
• test_similar_to_wildcards_match_newlines confirms that % and _ match newlines.
• test_similar_to covers basic %/_ semantics, full-string anchoring, and case sensitivity.
• test_similar_to_dynamic_pattern covers column-based patterns.
• test_similar_to_null_pattern and test_similar_to_non_literal_pattern_errors cover the NULL pattern and non-string literal pattern paths.

Translation and coercion:

• test_translate_scalar / test_translate_array cover the translation itself, including that each string variant (and its NULL) is preserved.
• similar_to_for_type_coercion in type_coercion.rs covers matching types, mismatched string types, a NULL pattern cast to the value's type, and the no-common-type error.

Protobuf (similar_to_pattern.rs proto_tests, mirroring the existing LikeExpr tests):

• Encoding, decoding, rejection of a non-SqlSimilarToPattern node, rejection of a missing expr field, and error propagation on both the encode and decode paths.
• roundtrip_sql_similar_to_pattern in datafusion/proto/tests/cases/roundtrip_physical_plan.rs covers the full plan roundtrip.

End-to-end (datafusion/sqllogictest/test_files/strings.slt):

• The pre-existing SIMILAR TO 'p[12].*' / NOT SIMILAR TO 'p[12].*' cases (which only worked because of the bug) were replaced with equivalent cases using standard wildcard syntax.
• New cases cover literal metachars, POSIX metachars, newline matching, dynamic column patterns, dynamic function patterns, SELECT 'a' SIMILAR TO NULL, rejection of SELECT 'a' SIMILAR TO 1, mixed Utf8 / LargeUtf8 / Utf8View operands, and dictionary-encoded values with both literal and dynamic patterns.

Are there any user-facing changes?

Yes:

• SIMILAR TO now produces correct results for queries that were previously returning wrong answers.
• Queries that relied on the buggy behavior (e.g., treating ., ^, or $ as regex metacharacters) now follow standard SQL SIMILAR TO semantics.
• Queries using valid SIMILAR TO POSIX metacharacters (| * + ? ( ) { } [ ]) now work as expected.
• % and _ wildcards now work.
• Non-literal patterns (e.g., column patterns) now work instead of returning a not_impl_err!, and physical plans containing them can be serialized with datafusion-proto.
• LargeUtf8 and Utf8View patterns are accepted, and mixing string types between the value and the pattern is coerced rather than failing.
• Dictionary-encoded values are coerced to their value type and work with both literal and dynamic patterns.
• SELECT ... SIMILAR TO NULL now returns NULL instead of crashing.
• SELECT ... SIMILAR TO <non-string> now returns a clean plan error instead of an internal error.

\ is still treated as a literal backslash rather than as the SQL default escape character, and an explicit ESCAPE clause is still rejected. Escape support is left as a follow-up.